/* 由 ecpg 处理（回归模式） */
/* 这些包含文件由预处理器添加 */
#include <ecpglib.h>
#include <ecpgerrno.h>
#include <sqlca.h>
/* 自动包含部分结束 */
#define ECPGdebug(X,Y) ECPGdebug((X)+100,(Y))

#line 1 "num_test2.pgc"
#include <stdio.h>
#include <stdlib.h>
#include <pgtypes_numeric.h>
#include <pgtypes_error.h>
#include <decimal.h>


#line 1 "regression.h"






#line 7 "num_test2.pgc"



#line 1 "printf_hack.h"
/*
 * print_double(x) 的效果与 printf("%g", x) 一致，但旨在
 * 在所有平台上产生相同的格式。
 */
static void fc_print_double(double fc_x)
{
#ifdef WIN32
	/* 将 Windows 的 3 位指数更改为看起来与其他人相同 */
	char		convert[128];
	int			vallen;

	sprintf(convert, "%g", x);
	vallen = strlen(convert);

	if (vallen >= 6 &&
		convert[vallen - 5] == 'e' &&
		convert[vallen - 3] == '0')
	{
		convert[vallen - 3] = convert[vallen - 2];
		convert[vallen - 2] = convert[vallen - 1];
		convert[vallen - 1] = '\0';
	}

	printf("%s", convert);
#else
	printf("%g", fc_x);
#endif
}

#line 9 "num_test2.pgc"



char* nums[] = { "2E394", "-2", ".794", "3.44", "592.49E21", "-32.84e4",
				 "2E-394", ".1E-2", "+.0", "-592.49E-07", "+32.84e-4",
				 ".500001", "-.5000001",
				 "1234567890123456789012345678.91", /* 30 位数字应该适合
				                                       进入十进制 */
				 "1234567890123456789012345678.921", /* 31 位数字不应该
				                                        适合十进制 */
				 "not a number",
				 NULL};


static void fc_check_errno(void);

int main(void)
{
	char *fc_text="error\n";
	char *fc_endptr;
	numeric *fc_num, *fc_nin;
	decimal *fc_dec;
	long fc_l;
	int fc_i, fc_j, fc_k, fc_q, fc_r, fc_count = 0;
	double fc_d;
	numeric **fc_numarr = (numeric **) calloc(1, sizeof(numeric));

	ECPGdebug(1, stderr);

	for (fc_i = 0; nums[fc_i]; fc_i++)
	{
		fc_num = PGTYPESnumeric_from_asc(nums[fc_i], &fc_endptr);
		if (!fc_num) fc_check_errno();
		if (fc_endptr != NULL)
		{
			printf("endptr of %d is not NULL\n", fc_i);
			if (*fc_endptr != '\0')
				printf("*endptr of %d is not \\0\n", fc_i);
		}
		if (!fc_num) continue;

		fc_numarr = realloc(fc_numarr, sizeof(numeric *) * (fc_count + 1));
		fc_numarr[fc_count++] = fc_num;

		fc_text = PGTYPESnumeric_to_asc(fc_num, -1);
		if (!fc_text) fc_check_errno();
		printf("num[%d,1]: %s\n", fc_i, fc_text); PGTYPESchar_free(fc_text);
		fc_text = PGTYPESnumeric_to_asc(fc_num, 0);
		if (!fc_text) fc_check_errno();
		printf("num[%d,2]: %s\n", fc_i, fc_text); PGTYPESchar_free(fc_text);
		fc_text = PGTYPESnumeric_to_asc(fc_num, 1);
		if (!fc_text) fc_check_errno();
		printf("num[%d,3]: %s\n", fc_i, fc_text); PGTYPESchar_free(fc_text);
		fc_text = PGTYPESnumeric_to_asc(fc_num, 2);
		if (!fc_text) fc_check_errno();
		printf("num[%d,4]: %s\n", fc_i, fc_text); PGTYPESchar_free(fc_text);

		fc_nin = PGTYPESnumeric_new();
		fc_text = PGTYPESnumeric_to_asc(fc_nin, 2);
		if (!fc_text) fc_check_errno();
		printf("num[%d,5]: %s\n", fc_i, fc_text); PGTYPESchar_free(fc_text);

		fc_r = PGTYPESnumeric_to_long(fc_num, &fc_l);
		if (fc_r) fc_check_errno();
		printf("num[%d,6]: %ld (r: %d)\n", fc_i, fc_r?0L:fc_l, fc_r);
		if (fc_r == 0)
		{
			fc_r = PGTYPESnumeric_from_long(fc_l, fc_nin);
			if (fc_r) fc_check_errno();
			fc_text = PGTYPESnumeric_to_asc(fc_nin, 2);
			fc_q = PGTYPESnumeric_cmp(fc_num, fc_nin);
			printf("num[%d,7]: %s (r: %d - cmp: %d)\n", fc_i, fc_text, fc_r, fc_q);
			PGTYPESchar_free(fc_text);
		}

		fc_r = PGTYPESnumeric_to_int(fc_num, &fc_k);
		if (fc_r) fc_check_errno();
		printf("num[%d,8]: %d (r: %d)\n", fc_i, fc_r?0:fc_k, fc_r);
		if (fc_r == 0)
		{
			fc_r = PGTYPESnumeric_from_int(fc_k, fc_nin);
			if (fc_r) fc_check_errno();
			fc_text = PGTYPESnumeric_to_asc(fc_nin, 2);
			fc_q = PGTYPESnumeric_cmp(fc_num, fc_nin);
			printf("num[%d,9]: %s (r: %d - cmp: %d)\n", fc_i, fc_text, fc_r, fc_q);
			PGTYPESchar_free(fc_text);
		}

		if (fc_i != 6)
		{
			/* 在多个架构上，下溢不可靠，因此在此不测试 */
			/* 这是一个 libc 问题，因为我们只调用 strtod() */

			fc_r = PGTYPESnumeric_to_double(fc_num, &fc_d);
			if (fc_r) fc_check_errno();
			printf("num[%d,10]: ", fc_i);
			fc_print_double(fc_r ? 0.0 : fc_d);
			printf(" (r: %d)\n", fc_r);
		}

		/* 不要测试双精度到数值的转换，因为
		 * - 不同架构上的额外数字不同
		 * - PGTYPESnumeric_from_double 内部 anyway 调用了 PGTYPESnumeric_from_asc
		 */

		fc_dec = PGTYPESdecimal_new();
		fc_r = PGTYPESnumeric_to_decimal(fc_num, fc_dec);
		if (fc_r) fc_check_errno();
		/* 我们没有专门的例程来输出十进制，它无论如何都会
		 * 转换为数值 */
		printf("num[%d,11]: - (r: %d)\n", fc_i, fc_r);
		if (fc_r == 0)
		{
			fc_r = PGTYPESnumeric_from_decimal(fc_dec, fc_nin);
			if (fc_r) fc_check_errno();
			fc_text = PGTYPESnumeric_to_asc(fc_nin, 2);
			fc_q = PGTYPESnumeric_cmp(fc_num, fc_nin);
			printf("num[%d,12]: %s (r: %d - cmp: %d)\n", fc_i, fc_text, fc_r, fc_q);
			PGTYPESchar_free(fc_text);
		}

		PGTYPESdecimal_free(fc_dec);
		PGTYPESnumeric_free(fc_nin);
		printf("\n");
	}

	for (fc_i = 0; fc_i < fc_count; fc_i++)
	{
		for (fc_j = 0; fc_j < fc_count; fc_j++)
		{
			numeric* fc_a = PGTYPESnumeric_new();
			numeric* fc_s = PGTYPESnumeric_new();
			numeric* fc_m = PGTYPESnumeric_new();
			numeric* fc_d = PGTYPESnumeric_new();
			fc_r = PGTYPESnumeric_add(fc_numarr[fc_i], fc_numarr[fc_j], fc_a);
			if (fc_r)
			{
				fc_check_errno();
				printf("r: %d\n", fc_r);
			}
			else
			{
				fc_text = PGTYPESnumeric_to_asc(fc_a, 10);
				printf("num[a,%d,%d]: %s\n", fc_i, fc_j, fc_text);
				PGTYPESchar_free(fc_text);
			}
			fc_r = PGTYPESnumeric_sub(fc_numarr[fc_i], fc_numarr[fc_j], fc_s);
			if (fc_r)
			{
				fc_check_errno();
				printf("r: %d\n", fc_r);
			}
			else
			{
				fc_text = PGTYPESnumeric_to_asc(fc_s, 10);
				printf("num[s,%d,%d]: %s\n", fc_i, fc_j, fc_text);
				PGTYPESchar_free(fc_text);
			}
			fc_r = PGTYPESnumeric_mul(fc_numarr[fc_i], fc_numarr[fc_j], fc_m);
			if (fc_r)
			{
				fc_check_errno();
				printf("r: %d\n", fc_r);
			}
			else
			{
				fc_text = PGTYPESnumeric_to_asc(fc_m, 10);
				printf("num[m,%d,%d]: %s\n", fc_i, fc_j, fc_text);
				PGTYPESchar_free(fc_text);
			}
			fc_r = PGTYPESnumeric_div(fc_numarr[fc_i], fc_numarr[fc_j], fc_d);
			if (fc_r)
			{
				fc_check_errno();
				printf("r: %d\n", fc_r);
			}
			else
			{
				fc_text = PGTYPESnumeric_to_asc(fc_d, 10);
				printf("num[d,%d,%d]: %s\n", fc_i, fc_j, fc_text);
				PGTYPESchar_free(fc_text);
			}

			PGTYPESnumeric_free(fc_a);
			PGTYPESnumeric_free(fc_s);
			PGTYPESnumeric_free(fc_m);
			PGTYPESnumeric_free(fc_d);
		}
	}

	for (fc_i = 0; fc_i < fc_count; fc_i++)
	{
		fc_text = PGTYPESnumeric_to_asc(fc_numarr[fc_i], -1);
		printf("%d: %s\n", fc_i, fc_text);
		PGTYPESchar_free(fc_text);
		PGTYPESnumeric_free(fc_numarr[fc_i]);
	}
	free(fc_numarr);

	return 0;
}

static void fc_check_errno(void)
{
	switch(errno)
	{
		case 0:
			printf("(no errno set) - ");
			break;
		case PGTYPES_NUM_OVERFLOW:
			printf("(errno == PGTYPES_NUM_OVERFLOW) - ");
			break;
		case PGTYPES_NUM_UNDERFLOW:
			printf("(errno == PGTYPES_NUM_UNDERFLOW) - ");
			break;
		case PGTYPES_NUM_BAD_NUMERIC:
			printf("(errno == PGTYPES_NUM_BAD_NUMERIC) - ");
			break;
		case PGTYPES_NUM_DIVIDE_ZERO:
			printf("(errno == PGTYPES_NUM_DIVIDE_ZERO) - ");
			break;
		default:
			printf("(unknown errno (%d))\n", errno);
			printf("(libc: (%s)) ", strerror(errno));
			break;
	}

}
